import store from '../store'
import path from 'path'
import fs from 'fs'
import os from 'os'
import { verbose } from 'sqlite3'

const sqlite3 = verbose()

const userDir = os.homedir()
const documentsFolder = path.join(userDir, '/Documents')
const sweetCircleFilesFolder = path.join(userDir, '/Documents/SweetCircleFiles')
let dataFolder = null
let msgFolder = null
let fileFolder = null

/**
 * 创建目录
 * @param dir
 */
const mkdirs = (dir) => {
  if (!fs.existsSync(dir)) {
    const parentDir = path.dirname(dir)
    if (parentDir !== dir) {
      mkdirs(parentDir)
    }
    fs.mkdirSync(dir)
  }
}

if (!fs.existsSync(documentsFolder)) {
  mkdirs(documentsFolder)
}
if (!fs.existsSync(sweetCircleFilesFolder)) {
  mkdirs(sweetCircleFilesFolder)
}

let db = null
/**
 * 创建数据库表
 * @returns {Promise}
 */
const createTable = () => {
  return new Promise((resolve, reject) => {
    db.serialize(() => {
      // 创建聊天消息表
      db.run(
        `create table if not exists chat_message
         (
           messageId      text    not null primary key, -- 消息唯一标识符
           messageType    integer not null,             -- 消息类型 1:更新联系人信息 2:文本消息 3:文件 4:好友申请 7:异地登陆
           messageCode    integer not null,             -- 消息代码 1:私聊 2:群聊
           messageContent text,                         -- 消息内容
           sessionId      text    not null,             -- 会话id 消息属于哪个会话 就是和那个用户的聊天消息
           sendUserId     text    not null,             -- 发送用户ID
           sendTime       integer not null,             -- 发送时间戳
           contactId      text    not null,             -- 联系人id 聊天消息属于哪个联系人 当前消息的联系人id 接收者id
           groupId        text    not null,             -- 群组id 聊天消息属于哪个群组
           fileSize       integer,                      -- 文件大小(字节)
           fileName       text,                         -- 文件名
           fileType       integer,                      -- 文件类型 1文档文件 2图片 3音频 4视频
           sendStatus     integer,                      -- 发送状态 0:正在发送 1:已发送 2:未接收 3:拒绝接收 4:对方未添加你为好友
           status         integer default 1             -- 消息状态(1:正常,0:删除)
         );`,
        (err) => {
          if (err) reject(err)
        }
      )

      // 创建聊天会话表
      db.run(
        `create table if not exists chat_session
         (
           sessionId       text    not null primary key, -- 会话唯一标识符
           sessionType     integer not null,             -- 会话类型 1:单聊，2:群聊
           userId          text    not null,             -- 登录用户id
           contactId       text    not null,             -- 联系人id 和登录用户聊天的用户id
           contactList     blob    null,                 -- 联系人列表 如果聊天方式是群聊 这就是群里的所有用户信息
           lastMessage     varchar(500),                 -- 最后一条消息内容
           lastReceiveTime bigint,                       -- 最后接收消息时间
           noReadCount     integer default 0,            -- 消息未读数
           topType         integer default 0,            -- 置顶类型(0:未置顶,1:置顶)
           status          integer default 1             -- 会话状态(1:正常,0:删除)
         );`,
        (err) => {
          if (err) reject(err)
        }
      )
    })
    resolve()
  })
}

// const createTable = () => {
//   return new Promise((resolve, reject) => {
//     db.serialize(() => {
//       db.run(
//         `create table chat_message
//          (
//            messageId      text    not null primary key,
//            messageType    integer not null,
//            messageCode    integer not null,
//            messageContent text,
//            sessionId      text    not null,
//            sendUserId     text    not null,
//            sendTime       integer not null,
//            contactId      text    not null,
//            groupId        text    not null,
//            fileSize       integer,
//            fileName       text,
//            fileType       integer,
//            sendStatus     integer,
//            status         integer default 1
//          );`,
//         (err) => {
//           if (err) reject(err)
//         }
//       )
//       db.run(
//         `create table chat_session
//          (
//            sessionId        text    not null primary key,
//            sessionType      integer not null,
//            userId           text    not null,
//            contactId        text    not null,
//            contactList      blob,
//            lastMessage      varchar(500),
//            lastReceiveTime bigint,
//            topType          integer default 0,
//            status            integer default 1
//          );`,
//         (err) => {
//           if (err) reject(err)
//         }
//       )
//     })
//     resolve()
//   })
// }

/**
 * 初始化函数
 *
 * 该函数用于初始化应用程序所需的数据目录结构和数据库
 * 包括创建用户数据文件夹、消息文件夹、文件存储文件夹
 * 以及初始化SQLite数据库和创建必要的数据表
 *
 * @returns {void}
 */
const init = () => {
  // 构建用户数据文件夹路径并创建文件夹（如果不存在）
  dataFolder = path.join(sweetCircleFilesFolder, `/sc_${store.getUserId()}`)
  if (!fs.existsSync(dataFolder)) {
    mkdirs(dataFolder)
  }

  // 创建消息存储文件夹（如果不存在）
  msgFolder = path.join(dataFolder, '/Msg')
  if (!fs.existsSync(msgFolder)) {
    mkdirs(msgFolder)
  }

  // 创建文件存储文件夹（如果不存在）
  fileFolder = path.join(dataFolder, '/Files')
  if (!fs.existsSync(fileFolder)) {
    mkdirs(fileFolder)
  }

  // 初始化SQLite数据库连接
  db = new sqlite3.Database(path.join(dataFolder, `/SweetCircleFiles.db`))

  // 创建数据表并处理初始化结果
  createTable()
    .then(() => {
      console.log('数据库初始化完成')
    })
    .catch((err) => {
      console.error('数据库初始化失败:', err)
    })
}

// /**
//  * a_b  =>  aB
//  * 将对象中的蛇形命名（snake_case）键转换为驼峰命名（camelCase）键。
//  * 如果对象的值也是对象，则递归地转换其键。
//  *
//  * @param {Object} obj - 需要转换键名的对象。
//  * @returns {Object} - 返回一个新对象，其键名已转换为驼峰命名。
//  */
// const convertSnakeToCamel = (obj) => {
//   const camelCaseObj = {}
//
//   // 使用 Object.keys() 避免 hasOwnProperty 问题
//   Object.keys(obj).forEach((key) => {
//     const camelKey = snakeToCamel(key)
//     camelCaseObj[camelKey] =
//       typeof obj[key] === 'object' && obj[key] !== null ? convertSnakeToCamel(obj[key]) : obj[key]
//   })
//
//   function snakeToCamel(snakeStr) {
//     return snakeStr
//       .split('_')
//       .map((word, index) => (index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
//       .join('')
//   }
//
//   return camelCaseObj
// }

// const convertSnakeToCamel = (obj) => {
//   const camelCaseObj = {}
//
//   for (const key in obj) {
//     if (obj.hasOwnProperty(key)) {
//       const camelKey = snakeToCamel(key)
//       camelCaseObj[camelKey] =
//         typeof obj[key] === 'object' && obj[key] !== null ? convertSnakeToCamel(obj[key]) : obj[key]
//     }
//   }
//
//   function snakeToCamel(snakeStr) {
//     return snakeStr
//       .split('_')
//       .map((word, index) => (index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
//       .join('')
//   }
//
//   return camelCaseObj
// }

/**
 * 获取所有状态为1的聊天会话列表。
 * @returns {Promise<{ status: boolean, msg: string, data: Array| [] }>}
 */
const getChatSessionList = () => {
  return new Promise((resolve) => {
    const stmt = db.prepare('select * from chat_session where status = 1')
    stmt.all([], (err, rows) => {
      if (err) {
        console.error(`Failed to get chat session list: ${err.message}`)
        resolve({ status: false, msg: `Failed to get chat session list: ${err.message}`, data: [] })
      } else {
        // rows.forEach((row, index) => {
        //   rows[index] = convertSnakeToCamel(row)
        // })
        resolve({ status: true, msg: `OK`, data: rows })
      }
      stmt.finalize()
    })
  })
}

/**
 * 添加一个新的聊天会话到数据库
 * @param {Object} sessionInfo
 * @returns {Promise<boolean>}
 */
const addChatSession = (sessionInfo) => {
  return new Promise((resolve) => {
    const stmt = db.prepare(
      'INSERT INTO chat_session (sessionId, sessionType, userId, contactId, contactList, lastMessage, lastReceiveTime, noReadCount, topType, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
    )
    const params = [
      sessionInfo.sessionId,
      sessionInfo.sessionType,
      sessionInfo.userId,
      sessionInfo.contactId,
      sessionInfo.contactList,
      sessionInfo.lastMessage,
      sessionInfo.lastReceiveTime,
      0,
      sessionInfo.topType,
      1
    ]
    stmt.run(params, (err) => {
      if (err) {
        resolve({ status: false, msg: `Failed to add chat session: ${err.message}` })
      } else {
        resolve({ status: true, msg: 'OK' })
      }
      stmt.finalize()
    })
  })
}

/**
 * 删除聊天会话
 * @param {string} sessionId
 * @returns {Promise<boolean>}
 */
const deleteChatSession = (sessionId) => {
  return new Promise((resolve) => {
    const stmt = db.prepare('DELETE FROM chat_session WHERE sessionId = ?')
    stmt.run(sessionId, (err) => {
      if (err) {
        resolve({ status: false, msg: `Failed to delete chat session: ${err.message}` })
      } else {
        resolve({ status: true, msg: 'OK' })
      }
      stmt.finalize()
    })
  })
}

/**
 * 更新聊天会话信息
 * @param {Object} sessionInfo
 * @returns {Promise<boolean>}
 */
const updateChatSession = (sessionInfo) => {
  let sql = 'UPDATE chat_session SET'
  const params = []
  for (const key of Object.keys(sessionInfo)) {
    if (key !== 'sessionId') {
      sql += ` ${key} = ?,`
      params.push(sessionInfo[key])
    }
  }
  sql = sql.slice(0, -1)
  sql += ' WHERE sessionId = ?'
  params.push(sessionInfo.sessionId)

  return new Promise((resolve) => {
    const stmt = db.prepare(sql)
    stmt.run(params, (err) => {
      if (err) {
        console.error(`Failed to update chat session: ${err.message}`)
        resolve(false)
      } else {
        resolve(true)
      }
      stmt.finalize()
    })
  })
}

/**
 * 添加聊天消息到数据库
 * @param {Object} data
 * @returns {Promise<boolean>}
 */
const addChatMessage = (data) => {
  return new Promise((resolve) => {
    const stmt = db.prepare(
      'INSERT INTO chat_message (messageId, messageType, messageCode, messageContent, sessionId, sendUserId, sendTime, contactId, groupId, fileSize, fileName, fileType, sendStatus, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
    )
    const params = [
      data.messageId,
      data.messageType,
      data.messageCode,
      data.messageContent,
      data.sessionId,
      data.sendUserId,
      data.sendTime,
      data.contactId,
      data.groupId,
      data.fileSize,
      data.fileName,
      data.fileType,
      data.sendStatus,
      1
    ]
    stmt.run(params, (err) => {
      if (err) {

        console.error(`Failed to add chat message: ${err.message}`)

        resolve({ status: false, msg: `Failed to add chat message: ${err.message}` })
      } else {
        resolve({ status: true, msg: 'OK' })
      }
      stmt.finalize()
    })
  })
}

/**
 * 获取指定会话ID的聊天消息列表
 * @param {string} sessionId
 * @returns {Promise<Array|boolean>}
 */
const getChatMessageList = (sessionId) => {
  return new Promise((resolve) => {
    const stmt = db.prepare('select * from chat_message where sessionId = ? and status = 1')
    stmt.all([sessionId], (err, rows) => {
      if (err) {
        console.error(`Failed to get chat message list: ${err.message}`)
        resolve(false)
      } else {
        // rows.forEach((row, index) => {
        //   rows[index] = convertSnakeToCamel(row)
        // })
        resolve(rows)
      }
      stmt.finalize()
    })
  })
}

/**
 * 删除聊天消息
 * @param {string} sessionId
 * @returns {Promise<boolean>}
 */
const deleteChatMessage = (sessionId) => {
  return new Promise((resolve) => {
    const stmt = db.prepare('delete from chat_message where sessionId = ?')
    stmt.run([sessionId], (err) => {
      if (err) {
        resolve({ status: false, msg: `Failed to delete chat message: ${err.message}` })
      } else {
        resolve({ status: true, msg: 'OK' })
      }
      stmt.finalize()
    })
  })
}

export default {
  init,
  getChatSessionList,
  addChatSession,
  deleteChatSession,
  updateChatSession,
  addChatMessage,
  getChatMessageList,
  deleteChatMessage
}

// import Table from './Table'
// import store from '../store'
//
// import path from 'path'
// import fs from 'fs'
// import os from 'os'
// import { verbose } from 'sqlite3'
//
// const sqlite3 = verbose()
// // const path = require('path')
// // const fs = require('fs')
// // const sqlite3 = require('sqlite3').verbose()
// // const os = require('os')
//
// const userDir = os.homedir()
// const documentsFolder = path.join(userDir, '/Documents')
// const sweetCircleFilesFolder = path.join(userDir, '/Documents/SweetCircleFiles')
// let dataFolder = null
// let msgFolder = null
// let fileFolder = null
//
// /**
//  * 创建目录
//  * @param dir
//  */
// const mkdirs = (dir) => {
//   if (!fs.existsSync(dir)) {
//     // 如果目录不存在则进行创建
//     const parentDir = path.dirname(dir) // 获取上级目录
//     if (parentDir !== dir) {
//       // 确保当前目录不为根目录
//       mkdirs(parentDir) // 递归调用自身创建上级目录
//     }
//     fs.mkdirSync(dir) // 创建当前目录
//   }
// }
// if (!fs.existsSync(documentsFolder)) {
//   mkdirs(documentsFolder)
// }
// if (!fs.existsSync(sweetCircleFilesFolder)) {
//   mkdirs(sweetCircleFilesFolder)
// }
//
// let db = null
//
// //所有表字段和属性对应关系
//
// const chatMessage = {
//   messageId: 'message_id',
//   messageType: 'message_type',
//   messageCode: 'message_code',
//   messageContent: 'message_content',
//   sessionId: 'session_id',
//   sendUserId: 'send_user_id',
//   sendTime: 'send_time',
//   contactId: 'contact_id',
//   groupId: 'group_id',
//   fileSize: 'file_size',
//   fileName: 'file_name',
//   fileType: 'file_type',
//   sendStatus: 'send_status',
//   status: 'status'
// }
// const chatSession = {
//   sessionId: 'session_id',
//   sessionType: 'session_type',
//   userId: 'user_id',
//   contactId: 'contact_id',
//   contactList: 'contact_list',
//   lastMessage: 'last_message',
//   lastReceiveTime: 'last_receive_time',
//   topType: 'top_type',
//   status: 'status'
// }
//
// /**
//  * 创建一个数据库表。
//  * 该函数返回一个Promise对象，用于异步执行数据库表的创建操作。
//  * 在函数内部，使用`db.serialize`确保表的创建操作按顺序执行。
//  *
//  * @returns {Promise} - 返回一个Promise对象，当表创建成功时resolve，失败时reject。
//  */
// const crateTable = () => {
//   return new Promise((resolve, reject) => {
//     // 使用db.serialize确保数据库操作按顺序执行
//     db.serialize(() => {
//       // 创建聊天消息表
//       db.run(Table.chatMessage)
//       // 创建聊天会话表
//       db.run(Table.chatSession)
//     })
//     // 表创建成功后resolve
//     resolve()
//   })
// }
//
// /**
//  * 初始化数据库 创建 数据库表 创建目录
//  * @param userId
//  */
// const init = () => {
//   dataFolder = path.join(sweetCircleFilesFolder, `/sc_${store.getUserId()}`)
//   if (!fs.existsSync(dataFolder)) {
//     mkdirs(dataFolder)
//   }
//   msgFolder = path.join(dataFolder, '/Msg')
//   if (!fs.existsSync(msgFolder)) {
//     mkdirs(msgFolder)
//   }
//   fileFolder = path.join(dataFolder, '/Files')
//   if (!fs.existsSync(fileFolder)) {
//     mkdirs(fileFolder)
//   }
//   db = new sqlite3.Database(path.join(dataFolder, `/SweetCircleFiles.db`))
//   crateTable().then()
//   console.log('数据库初始化完成')
// }
//
// /**
//  * a_b  =>  aB
//  * 将对象中的蛇形命名（snake_case）键转换为驼峰命名（camelCase）键。
//  * 如果对象的值也是对象，则递归地转换其键。
//  *
//  * @param {Object} obj - 需要转换键名的对象。
//  * @returns {Object} - 返回一个新对象，其键名已转换为驼峰命名。
//  */
// const convertSnakeToCamel = (obj) => {
//   const camelCaseObj = {}
//
//   // 遍历对象的每个键
//   for (const key in obj) {
//     if (obj.hasOwnProperty(key)) {
//       // 将蛇形命名的键转换为驼峰命名
//       const camelKey = snakeToCamel(key)
//
//       // 如果值是对象且不为 null，则递归转换；否则直接赋值
//       camelCaseObj[camelKey] =
//         typeof obj[key] === 'object' && obj[key] !== null ? convertSnakeToCamel(obj[key]) : obj[key]
//     }
//   }
//
//   /**
//    * 将蛇形命名的字符串转换为驼峰命名的字符串。
//    *
//    * @param {string} snakeStr - 需要转换的蛇形命名字符串。
//    * @returns {string} - 返回转换后的驼峰命名字符串。
//    */
//   function snakeToCamel(snakeStr) {
//     return snakeStr
//       .split('_')
//       .map((word, index) => (index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
//       .join('')
//   }
//
//   return camelCaseObj
// }
//
// /**
//  * 获取所有状态为1的聊天会话列表。
//  * 该函数返回一个Promise对象，成功时返回转换后的聊天会话列表，失败时返回false。
//  *
//  * @returns {Promise<Array|boolean>} - 返回一个Promise，成功时返回聊天会话列表（已转换为驼峰命名），失败时返回false。
//  */
// const getChatSessionList = () => {
//   return new Promise((resolve, reject) => {
//     // 预编译SQL语句以防止SQL注入
//     const stmt = db.prepare('select * from chat_session where status = 1')
//
//     // 执行查询并处理结果
//     stmt.all([], (err, rows) => {
//       if (err) {
//         // 如果查询失败，记录错误信息并返回false
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 将查询结果中的蛇形命名转换为驼峰命名
//         rows.forEach((row, index) => {
//           rows[index] = convertSnakeToCamel(row)
//         })
//         // 返回转换后的聊天会话列表
//         resolve(rows)
//       }
//       // 释放预编译语句的资源
//       stmt.finalize()
//     })
//   })
// }
//
// /**
//  * 添加一个新的聊天会话到数据库
//  *
//  * 该函数接收一个包含会话信息的对象，并将其插入到数据库的 `chat_session` 表中。
//  * 使用预编译语句来防止 SQL 注入，并返回一个 Promise，表示操作是否成功。
//  *
//  * @param {Object} sessionInfo - 包含会话信息的对象
//  * @param {string} sessionInfo.sessionId - 会话的唯一标识符
//  * @param {string} sessionInfo.sessionType - 会话类型
//  * @param {string} sessionInfo.userId - 用户ID
//  * @param {string} sessionInfo.contactId - 联系人ID
//  * @param {string} sessionInfo.contactList - 联系人列表
//  * @param {string} sessionInfo.lastMessage - 最后一条消息
//  * @param {string} sessionInfo.lastReceiveTime - 最后接收消息的时间
//  * @param {string} sessionInfo.topType - 置顶类型
//  * @returns {Promise<boolean>} - 返回一个 Promise，表示操作是否成功。`true` 表示成功，`false` 表示失败。
//  */
// const addChatSession = (sessionInfo) => {
//   return new Promise(async (resolve, reject) => {
//     // 准备 SQL 插入语句，使用预编译语句来防止 SQL 注入
//     const stmt = db.prepare(
//       'INSERT INTO chat_session (session_id, session_type, user_id, contact_id, contact_list,last_message,last_receive_time,top_type, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
//     )
//
//     // 构建 SQL 参数数组
//     const params = [
//       sessionInfo.sessionId,
//       sessionInfo.sessionType,
//       sessionInfo.userId,
//       sessionInfo.contactId,
//       sessionInfo.contactList,
//       sessionInfo.lastMessage,
//       sessionInfo.lastReceiveTime,
//       sessionInfo.topType,
//       1
//     ]
//
//     // 执行 SQL 语句
//     stmt.run(params, (err, row) => {
//       if (err) {
//         // 如果发生错误，记录错误信息并返回 `false`
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 如果成功，返回 `true`
//         resolve(true)
//       }
//
//       // 确保在所有操作完成后释放资源
//       stmt.finalize()
//     })
//   })
// }
//
// const deleteChatSession = (sessionId) => {
//   return new Promise(async (resolve, reject) => {
//     // 准备 SQL 删除语句，使用预编译语句来防止 SQL 注入
//     const stmt = db.prepare('DELETE FROM chat_session WHERE session_id = ?')
//
//     // 执行 SQL 语句
//     stmt.run(sessionId, async (err, row) => {
//       if (err) {
//         // 如果发生错误，记录错误信息并返回 `false`
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 如果成功，返回 `true`
//         resolve(true)
//       }
//
//       // 确保在所有操作完成后释放资源
//       stmt.finalize()
//     })
//   })
// }
//
// /**
//  * 更新聊天会话信息
//  *
//  * 该函数用于更新数据库中的聊天会话信息。它根据传入的会话信息动态生成 SQL 更新语句，
//  * 并使用预编译语句来防止 SQL 注入。最后，它返回一个 Promise，表示更新操作是否成功。
//  *
//  * @param {Object} sessionInfo - 包含要更新的会话信息的对象，键为数据库字段名，值为对应的新值。
//  * @returns {Promise<boolean>} - 返回一个 Promise，成功时解析为 true，失败时解析为 false。
//  */
// const updateChatSession = (sessionInfo) => {
//   // 构建 SQL 更新语句的基础部分
//   let sql = 'update chat_session set'
//
//   // 遍历 sessionInfo 对象，动态添加 SQL 更新字段和值
//   for (const key of Object.keys(sessionInfo)) {
//     sql += ` ${chatSession[key]} = ${sessionInfo[key]},`
//   }
//
//   // 删除 SQL 语句中最后一个多余的逗号
//   sql = sql.slice(0, -1)
//
//   // 添加 WHERE 条件，指定要更新的会话 ID
//   sql += ' where session_id = ?'
//
//   // 返回一个 Promise，执行数据库更新操作
//   return new Promise(async (resolve, reject) => {
//     // 预编译 SQL 语句，防止 SQL 注入
//     const stmt = db.prepare(sql)
//
//     // 执行预编译语句，并处理结果
//     stmt.run((err, row) => {
//       if (err) {
//         // 如果发生错误，记录错误信息并返回 false
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 如果成功，返回 true
//         resolve(true)
//       }
//
//       // 确保在所有操作完成后释放资源
//       stmt.finalize()
//     })
//   })
// }
//
// /*
// 离线消息对象
// {
//   "messageId": "9E04797D4F90B5A7637FC1B4172B083D",
//   "messageType": 2,
//   "messageCode": 1,
//   "messageContent": "100",
//   "sessionId": "DCF7C21258C8CFE70B82C68BD54ADA48",
//   "sendUserId": "1629A0960C9441BC96F2EB6852224E7E",
//   "sendTime": 1739579412544,
//   "contactId": "DCF7C21258C8CFE70B82C68BD54ADA48",
//   "groupId": "DCF7C21258C8CFE70B82C68BD54ADA48",
//   "fileSize": null,
//   "fileName": null,
//   "fileType": null,
//   "sendStatus": 2,
//   "status": 1
// }
//  */
// /**
//  * 添加聊天消息到数据库
//  *
//  * 该函数接收一个包含聊天消息数据的对象，并将其插入到数据库的 `chat_message` 表中。
//  * 使用预编译语句来防止 SQL 注入，并返回一个 Promise，表示操作是否成功。
//  *
//  * @param {Object} data - 包含聊天消息数据的对象
//  * @param {string} data.messageId - 消息的唯一标识符
//  * @param {string} data.messageType - 消息类型
//  * @param {string} data.messageCode - 消息代码
//  * @param {string} data.messageContent - 消息内容
//  * @param {string} data.sessionId - 会话的唯一标识符
//  * @param {string} data.sendUserId - 发送用户的唯一标识符
//  * @param {string} data.sendTime - 消息发送时间
//  * @param {string} data.contactId - 联系人的唯一标识符
//  * @param {string} data.groupId - 群组的唯一标识符
//  * @param {number} data.fileSize - 文件大小（如果有文件）
//  * @param {string} data.fileName - 文件名（如果有文件）
//  * @param {string} data.fileType - 文件类型（如果有文件）
//  * @param {string} data.sendStatus - 消息发送状态
//  * @returns {Promise<boolean>} - 返回一个 Promise，表示消息是否成功插入到数据库
//  */
// const addChatMessage = (data) => {
//   return new Promise(async (resolve, reject) => {
//     // 准备 SQL 插入语句，使用预编译语句来防止 SQL 注入
//     const stmt = db.prepare(
//       'INSERT INTO chat_message (message_id, message_type, message_code, message_content,session_id,send_user_id,send_time,contact_id,group_id,file_size,file_name,file_type,send_status,status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
//     )
//
//     // 构建 SQL 语句的参数数组
//     const params = [
//       data.messageId,
//       data.messageType,
//       data.messageCode,
//       data.messageContent,
//       data.sessionId,
//       data.sendUserId,
//       data.sendTime,
//       data.contactId,
//       data.groupId,
//       data.fileSize,
//       data.fileName,
//       data.fileType,
//       data.sendStatus,
//       1
//     ]
//
//     // 执行 SQL 语句并处理结果
//     stmt.run(params, (err, row) => {
//       if (err) {
//         // 如果发生错误，记录错误信息并返回 false
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 如果操作成功，返回 true
//         resolve(true)
//       }
//
//       // 确保在所有操作完成后释放资源
//       stmt.finalize()
//     })
//   })
// }
//
// /**
//  * 获取指定会话ID的聊天消息列表
//  *
//  * 该函数通过查询数据库获取指定会话ID的所有状态为1的聊天消息，并按发送时间降序排列。
//  * 查询结果中的字段名会从蛇形命名转换为驼峰命名。
//  *
//  * @param {string} sessionId - 会话的唯一标识符，用于查询对应的聊天消息
//  * @returns {Promise<Array|boolean>} - 返回一个Promise对象，解析为聊天消息数组（字段名为驼峰命名），如果查询失败则解析为false
//  */
// const getChatMessageList = (sessionId) => {
//   return new Promise(async (resolve, reject) => {
//     // 准备SQL语句，查询指定会话ID且状态为1的聊天消息，并按发送时间降序排列
//     const stmt = db.prepare('select * from chat_message where session_id = ? and status = 1')
//
//     // 执行SQL查询，传入会话ID作为参数
//     stmt.all([sessionId], (err, rows) => {
//       if (err) {
//         // 如果查询出错，打印错误信息并返回false
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 遍历查询结果，将每条记录的字段名从蛇形命名转换为驼峰命名
//         rows.forEach(async (row, index) => {
//           rows[index] = convertSnakeToCamel(row)
//         })
//         // 返回转换后的聊天消息数组
//         resolve(rows)
//       }
//       // 释放SQL语句占用的资源
//       stmt.finalize()
//     })
//   })
// }
//
// const deleteChatMessage = (sessionId) => {
//   return new Promise(async (resolve, reject) => {
//     // 准备SQL语句，删除指定消息ID的聊天消息
//     const stmt = db.prepare('delete from chat_message where session_id = ?')
//
//     // 执行SQL查询，传入消息ID作为参数
//     stmt.run([sessionId], (err, rows) => {
//       if (err) {
//         // 如果查询出错，打印错误信息并返回false
//         console.error(`Failed to save chat session: ${err.message}`)
//         resolve(false)
//       } else {
//         // 返回转换后的聊天消息数组
//         resolve(true)
//       }
//       // 释放SQL
//     })
//   })
// }
//
// export default {
//   init,
//   getChatSessionList,
//   addChatSession,
//   deleteChatSession,
//   updateChatSession,
//   addChatMessage,
//   getChatMessageList,
//   deleteChatMessage
// }
